home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / collections / ListCollectionView.as < prev    next >
Encoding:
Text File  |  2008-05-21  |  40.8 KB  |  1,436 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.system.ApplicationDomain;
  6.    import flash.utils.Proxy;
  7.    import flash.utils.flash_proxy;
  8.    import flash.utils.getQualifiedClassName;
  9.    import mx.collections.errors.CollectionViewError;
  10.    import mx.collections.errors.ItemPendingError;
  11.    import mx.core.IMXMLObject;
  12.    import mx.core.mx_internal;
  13.    import mx.events.CollectionEvent;
  14.    import mx.events.CollectionEventKind;
  15.    import mx.events.PropertyChangeEvent;
  16.    import mx.resources.ResourceBundle;
  17.    import mx.utils.ObjectUtil;
  18.    import mx.utils.StringUtil;
  19.    
  20.    use namespace mx_internal;
  21.    use namespace flash_proxy;
  22.    
  23.    public class ListCollectionView extends Proxy implements ICollectionView, IList, IMXMLObject
  24.    {
  25.       private static var resourceInvalidIndex:String;
  26.       
  27.       private static var resourceBookmarkNotFound:String;
  28.       
  29.       private static var resourceOutOfBounds:String;
  30.       
  31.       private static var resourceUnknownProperty:String;
  32.       
  33.       private static var resourceIncorrectAddition:String;
  34.       
  35.       private static var resourceItemNotFound:String;
  36.       
  37.       mx_internal static const VERSION:String = "2.0.1.0";
  38.       
  39.       private static var packageResources:ResourceBundle = ResourceBundle.getResourceBundle("collections",ApplicationDomain.currentDomain);
  40.       
  41.       loadResources();
  42.       
  43.       private var autoUpdateCounter:int;
  44.       
  45.       private var _list:IList;
  46.       
  47.       protected var localIndex:Array;
  48.       
  49.       private var _filterFunction:Function;
  50.       
  51.       private var pendingUpdates:Array;
  52.       
  53.       private var eventDispatcher:EventDispatcher;
  54.       
  55.       private var revision:int;
  56.       
  57.       private var _sort:Sort;
  58.       
  59.       public function ListCollectionView(param1:IList = null)
  60.       {
  61.          super();
  62.          eventDispatcher = new EventDispatcher(this);
  63.          this.list = param1;
  64.       }
  65.       
  66.       private static function loadResources() : void
  67.       {
  68.          resourceOutOfBounds = packageResources.getString("outOfBounds");
  69.          resourceInvalidIndex = packageResources.getString("invalidIndex");
  70.          resourceUnknownProperty = packageResources.getString("unknownProperty");
  71.          resourceIncorrectAddition = packageResources.getString("incorrectAddition");
  72.          resourceItemNotFound = packageResources.getString("itemNotFound");
  73.          resourceBookmarkNotFound = packageResources.getString("bookmarkNotFound");
  74.       }
  75.       
  76.       public function set filterFunction(param1:Function) : void
  77.       {
  78.          _filterFunction = param1;
  79.          dispatchEvent(new Event("filterFunctionChanged"));
  80.       }
  81.       
  82.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  83.       {
  84.          eventDispatcher.removeEventListener(param1,param2,param3);
  85.       }
  86.       
  87.       private function replaceItemsInView(param1:Array, param2:int, param3:Boolean = true) : void
  88.       {
  89.          var _loc4_:int = 0;
  90.          var _loc5_:Array = null;
  91.          var _loc6_:Array = null;
  92.          var _loc7_:int = 0;
  93.          var _loc8_:PropertyChangeEvent = null;
  94.          var _loc9_:CollectionEvent = null;
  95.          if(localIndex)
  96.          {
  97.             _loc4_ = int(param1.length);
  98.             _loc5_ = [];
  99.             _loc6_ = [];
  100.             _loc7_ = 0;
  101.             while(_loc7_ < _loc4_)
  102.             {
  103.                _loc8_ = param1[_loc7_];
  104.                _loc5_.push(_loc8_.oldValue);
  105.                _loc6_.push(_loc8_.newValue);
  106.                _loc7_++;
  107.             }
  108.             removeItemsFromView(_loc5_,param2,param3);
  109.             addItemsToView(_loc6_,param2,param3);
  110.          }
  111.          else
  112.          {
  113.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  114.             _loc9_.kind = CollectionEventKind.REPLACE;
  115.             _loc9_.location = param2;
  116.             _loc9_.items = param1;
  117.             dispatchEvent(_loc9_);
  118.          }
  119.       }
  120.       
  121.       public function willTrigger(param1:String) : Boolean
  122.       {
  123.          return eventDispatcher.willTrigger(param1);
  124.       }
  125.       
  126.       private function handlePendingUpdates() : void
  127.       {
  128.          var _loc1_:Array = null;
  129.          var _loc2_:CollectionEvent = null;
  130.          var _loc3_:int = 0;
  131.          var _loc4_:CollectionEvent = null;
  132.          var _loc5_:int = 0;
  133.          if(pendingUpdates)
  134.          {
  135.             _loc1_ = pendingUpdates;
  136.             pendingUpdates = null;
  137.             _loc3_ = 0;
  138.             while(_loc3_ < _loc1_.length)
  139.             {
  140.                _loc4_ = _loc1_[_loc3_];
  141.                if(_loc4_.kind == CollectionEventKind.UPDATE)
  142.                {
  143.                   if(!_loc2_)
  144.                   {
  145.                      _loc2_ = _loc4_;
  146.                   }
  147.                   else
  148.                   {
  149.                      _loc5_ = 0;
  150.                      while(_loc5_ < _loc4_.items.length)
  151.                      {
  152.                         _loc2_.items.push(_loc4_.items[_loc5_]);
  153.                         _loc5_++;
  154.                      }
  155.                   }
  156.                }
  157.                else
  158.                {
  159.                   listChangeHandler(_loc4_);
  160.                }
  161.                _loc3_++;
  162.             }
  163.             if(_loc2_)
  164.             {
  165.                listChangeHandler(_loc2_);
  166.             }
  167.          }
  168.       }
  169.       
  170.       mx_internal function findItem(param1:Object, param2:String, param3:Boolean = false) : int
  171.       {
  172.          if(!sort)
  173.          {
  174.             throw new CollectionViewError(resourceItemNotFound);
  175.          }
  176.          if(localIndex.length == 0)
  177.          {
  178.             return param3 ? 0 : -1;
  179.          }
  180.          return sort.findItem(localIndex,param1,param2,param3);
  181.       }
  182.       
  183.       override flash_proxy function hasProperty(param1:*) : Boolean
  184.       {
  185.          var index:int = 0;
  186.          var n:Number = NaN;
  187.          var name:* = param1;
  188.          if(name is QName)
  189.          {
  190.             name = name.localName;
  191.          }
  192.          index = -1;
  193.          try
  194.          {
  195.             n = parseInt(String(name));
  196.             if(!isNaN(n))
  197.             {
  198.                index = int(n);
  199.             }
  200.          }
  201.          catch(e:Error)
  202.          {
  203.          }
  204.          if(index == -1)
  205.          {
  206.             return false;
  207.          }
  208.          return index >= 0 && index < length;
  209.       }
  210.       
  211.       public function removeAll() : void
  212.       {
  213.          var _loc1_:int = 0;
  214.          var _loc2_:int = 0;
  215.          _loc1_ = length;
  216.          if(_loc1_ > 0)
  217.          {
  218.             if(localIndex)
  219.             {
  220.                _loc2_ = _loc1_ - 1;
  221.                while(_loc2_ >= 0)
  222.                {
  223.                   removeItemAt(_loc2_);
  224.                   _loc2_--;
  225.                }
  226.             }
  227.             else
  228.             {
  229.                list.removeAll();
  230.             }
  231.          }
  232.       }
  233.       
  234.       [Bindable("collectionChange")]
  235.       public function getItemAt(param1:int, param2:int = 0) : Object
  236.       {
  237.          if(param1 < 0 || param1 >= length)
  238.          {
  239.             throw new RangeError(StringUtil.substitute(resourceOutOfBounds,param1));
  240.          }
  241.          if(localIndex)
  242.          {
  243.             return localIndex[param1];
  244.          }
  245.          if(list)
  246.          {
  247.             return list.getItemAt(param1,param2);
  248.          }
  249.          return null;
  250.       }
  251.       
  252.       private function moveItemInView(param1:Object, param2:Boolean = true, param3:Array = null) : void
  253.       {
  254.          var _loc4_:int = 0;
  255.          var _loc5_:int = 0;
  256.          var _loc6_:int = 0;
  257.          var _loc7_:CollectionEvent = null;
  258.          if(localIndex)
  259.          {
  260.             _loc4_ = -1;
  261.             _loc5_ = 0;
  262.             while(_loc5_ < localIndex.length)
  263.             {
  264.                if(localIndex[_loc5_] == param1)
  265.                {
  266.                   _loc4_ = _loc5_;
  267.                   break;
  268.                }
  269.                _loc5_++;
  270.             }
  271.             if(_loc4_ > -1)
  272.             {
  273.                localIndex.splice(_loc4_,1);
  274.             }
  275.             _loc6_ = addItemsToView([param1],-1,false);
  276.             if(param2)
  277.             {
  278.                _loc7_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  279.                _loc7_.items.push(param1);
  280.                if(param3 && _loc6_ == _loc4_ && _loc6_ > -1)
  281.                {
  282.                   param3.push(param1);
  283.                   return;
  284.                }
  285.                if(_loc6_ > -1 && _loc4_ > -1)
  286.                {
  287.                   _loc7_.kind = CollectionEventKind.MOVE;
  288.                   _loc7_.location = _loc6_;
  289.                   _loc7_.oldLocation = _loc4_;
  290.                }
  291.                else if(_loc6_ > -1)
  292.                {
  293.                   _loc7_.kind = CollectionEventKind.ADD;
  294.                   _loc7_.location = _loc6_;
  295.                }
  296.                else if(_loc4_ > -1)
  297.                {
  298.                   _loc7_.kind = CollectionEventKind.REMOVE;
  299.                   _loc7_.location = _loc4_;
  300.                }
  301.                else
  302.                {
  303.                   param2 = false;
  304.                }
  305.                if(param2)
  306.                {
  307.                   dispatchEvent(_loc7_);
  308.                }
  309.             }
  310.          }
  311.       }
  312.       
  313.       override flash_proxy function nextName(param1:int) : String
  314.       {
  315.          return (param1 - 1).toString();
  316.       }
  317.       
  318.       public function contains(param1:Object) : Boolean
  319.       {
  320.          return getItemIndex(param1) != -1;
  321.       }
  322.       
  323.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  324.       {
  325.          list.itemUpdated(param1,param2,param3,param4);
  326.       }
  327.       
  328.       private function removeItemsFromView(param1:Array, param2:int, param3:Boolean = true) : void
  329.       {
  330.          var _loc4_:Array = null;
  331.          var _loc5_:int = 0;
  332.          var _loc6_:int = 0;
  333.          var _loc7_:Object = null;
  334.          var _loc8_:int = 0;
  335.          var _loc9_:CollectionEvent = null;
  336.          _loc4_ = !!localIndex ? [] : param1;
  337.          _loc5_ = param2;
  338.          if(localIndex)
  339.          {
  340.             _loc6_ = 0;
  341.             while(_loc6_ < param1.length)
  342.             {
  343.                _loc7_ = param1[_loc6_];
  344.                _loc8_ = getItemIndex(_loc7_);
  345.                if(_loc8_ > -1)
  346.                {
  347.                   localIndex.splice(_loc8_,1);
  348.                   _loc4_.push(_loc7_);
  349.                   _loc5_ = _loc8_;
  350.                }
  351.                _loc6_++;
  352.             }
  353.          }
  354.          if(param3 && _loc4_.length > 0)
  355.          {
  356.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  357.             _loc9_.kind = CollectionEventKind.REMOVE;
  358.             _loc9_.location = !localIndex || _loc4_.length == 1 ? _loc5_ : -1;
  359.             _loc9_.items = _loc4_;
  360.             dispatchEvent(_loc9_);
  361.          }
  362.       }
  363.       
  364.       mx_internal function getBookmark(param1:int) : ListCollectionViewBookmark
  365.       {
  366.          var value:Object = null;
  367.          var index:int = param1;
  368.          if(index < 0 || index > length)
  369.          {
  370.             throw new CollectionViewError(StringUtil.substitute(resourceInvalidIndex,index));
  371.          }
  372.          try
  373.          {
  374.             value = getItemAt(index);
  375.          }
  376.          catch(e:Error)
  377.          {
  378.             value = null;
  379.          }
  380.          return new ListCollectionViewBookmark(value,this,revision,index);
  381.       }
  382.       
  383.       [Bindable("sortChanged")]
  384.       public function get sort() : Sort
  385.       {
  386.          return _sort;
  387.       }
  388.       
  389.       public function addItemAt(param1:Object, param2:int) : void
  390.       {
  391.          var _loc3_:int = 0;
  392.          if(param2 < 0 || !list || param2 > length)
  393.          {
  394.             throw new RangeError(StringUtil.substitute(resourceOutOfBounds,param2));
  395.          }
  396.          _loc3_ = param2;
  397.          if(Boolean(localIndex) && Boolean(sort))
  398.          {
  399.             _loc3_ = list.length;
  400.          }
  401.          list.addItemAt(param1,_loc3_);
  402.       }
  403.       
  404.       private function handlePropertyChangeEvents(param1:Array) : void
  405.       {
  406.          var _loc2_:Array = null;
  407.          var _loc3_:Array = null;
  408.          var _loc4_:Object = null;
  409.          var _loc5_:int = 0;
  410.          var _loc6_:Array = null;
  411.          var _loc7_:int = 0;
  412.          var _loc8_:PropertyChangeEvent = null;
  413.          var _loc9_:Object = null;
  414.          var _loc10_:* = false;
  415.          var _loc11_:int = 0;
  416.          var _loc12_:int = 0;
  417.          var _loc13_:CollectionEvent = null;
  418.          _loc2_ = param1;
  419.          if(Boolean(sort) || filterFunction != null)
  420.          {
  421.             _loc3_ = [];
  422.             _loc5_ = 0;
  423.             while(_loc5_ < param1.length)
  424.             {
  425.                _loc8_ = param1[_loc5_];
  426.                if(_loc8_.target)
  427.                {
  428.                   _loc9_ = _loc8_.target;
  429.                   _loc10_ = _loc8_.target != _loc8_.source;
  430.                }
  431.                else
  432.                {
  433.                   _loc9_ = _loc8_.source;
  434.                   _loc10_ = false;
  435.                }
  436.                _loc11_ = 0;
  437.                while(_loc11_ < _loc3_.length)
  438.                {
  439.                   if(_loc3_[_loc11_].item == _loc9_)
  440.                   {
  441.                      break;
  442.                   }
  443.                   _loc11_++;
  444.                }
  445.                if(_loc11_ < _loc3_.length)
  446.                {
  447.                   _loc4_ = _loc3_[_loc11_];
  448.                }
  449.                else
  450.                {
  451.                   _loc4_ = {
  452.                      "item":_loc9_,
  453.                      "move":_loc10_,
  454.                      "event":_loc8_
  455.                   };
  456.                   _loc3_.push(_loc4_);
  457.                }
  458.                _loc4_.move = _loc4_.move || filterFunction || !_loc8_.property || sort && sort.propertyAffectsSort(String(_loc8_.property));
  459.                _loc5_++;
  460.             }
  461.             _loc2_ = [];
  462.             _loc5_ = 0;
  463.             while(_loc5_ < _loc3_.length)
  464.             {
  465.                _loc4_ = _loc3_[_loc5_];
  466.                if(_loc4_.move)
  467.                {
  468.                   moveItemInView(_loc4_.item,_loc4_.item,_loc2_);
  469.                }
  470.                else
  471.                {
  472.                   _loc2_.push(_loc4_.item);
  473.                }
  474.                _loc5_++;
  475.             }
  476.             _loc6_ = new Array();
  477.             _loc7_ = 0;
  478.             while(_loc7_ < _loc2_.length)
  479.             {
  480.                _loc12_ = 0;
  481.                while(_loc12_ < _loc3_.length)
  482.                {
  483.                   if(_loc2_[_loc7_] == _loc3_[_loc12_].item)
  484.                   {
  485.                      _loc6_.push(_loc3_[_loc12_].event);
  486.                   }
  487.                   _loc12_++;
  488.                }
  489.                _loc7_++;
  490.             }
  491.             _loc2_ = _loc6_;
  492.          }
  493.          if(_loc2_.length > 0)
  494.          {
  495.             _loc13_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  496.             _loc13_.kind = CollectionEventKind.UPDATE;
  497.             _loc13_.items = _loc2_;
  498.             dispatchEvent(_loc13_);
  499.          }
  500.       }
  501.       
  502.       [Bindable("listChanged")]
  503.       public function get list() : IList
  504.       {
  505.          return _list;
  506.       }
  507.       
  508.       private function populateLocalIndex() : void
  509.       {
  510.          if(list)
  511.          {
  512.             localIndex = list.toArray();
  513.          }
  514.          else
  515.          {
  516.             localIndex = [];
  517.          }
  518.       }
  519.       
  520.       public function set sort(param1:Sort) : void
  521.       {
  522.          _sort = param1;
  523.          dispatchEvent(new Event("sortChanged"));
  524.       }
  525.       
  526.       override flash_proxy function nextValue(param1:int) : *
  527.       {
  528.          return getItemAt(param1 - 1);
  529.       }
  530.       
  531.       private function addItemsToView(param1:Array, param2:int, param3:Boolean = true) : int
  532.       {
  533.          var _loc4_:Array = null;
  534.          var _loc5_:int = 0;
  535.          var _loc6_:int = 0;
  536.          var _loc7_:int = 0;
  537.          var _loc8_:Object = null;
  538.          var _loc9_:CollectionEvent = null;
  539.          _loc4_ = !!localIndex ? [] : param1;
  540.          _loc5_ = param2;
  541.          if(localIndex)
  542.          {
  543.             _loc6_ = param2;
  544.             _loc7_ = 0;
  545.             while(_loc7_ < param1.length)
  546.             {
  547.                _loc8_ = param1[_loc7_];
  548.                if(filterFunction == null || filterFunction(_loc8_))
  549.                {
  550.                   if(sort)
  551.                   {
  552.                      _loc5_ = _loc6_ = mx_internal::findItem(_loc8_,Sort.ANY_INDEX_MODE,true);
  553.                   }
  554.                   if(sort && sort.unique && sort.compareFunction(_loc8_,localIndex[_loc6_]) == 0)
  555.                   {
  556.                      throw new CollectionViewError(resourceIncorrectAddition);
  557.                   }
  558.                   localIndex.splice(_loc6_++,0,_loc8_);
  559.                   _loc4_.push(_loc8_);
  560.                }
  561.                _loc7_++;
  562.             }
  563.          }
  564.          if(Boolean(localIndex) && _loc4_.length > 1)
  565.          {
  566.             _loc5_ = -1;
  567.          }
  568.          if(param3 && _loc4_.length > 0)
  569.          {
  570.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  571.             _loc9_.kind = CollectionEventKind.ADD;
  572.             _loc9_.location = _loc5_;
  573.             _loc9_.items = _loc4_;
  574.             dispatchEvent(_loc9_);
  575.          }
  576.          return _loc5_;
  577.       }
  578.       
  579.       public function dispatchEvent(param1:Event) : Boolean
  580.       {
  581.          return eventDispatcher.dispatchEvent(param1);
  582.       }
  583.       
  584.       public function getItemIndex(param1:Object) : int
  585.       {
  586.          var _loc2_:int = 0;
  587.          var _loc3_:int = 0;
  588.          var _loc4_:int = 0;
  589.          var _loc5_:int = 0;
  590.          if(sort)
  591.          {
  592.             _loc3_ = sort.findItem(localIndex,param1,Sort.FIRST_INDEX_MODE);
  593.             if(_loc3_ == -1)
  594.             {
  595.                return -1;
  596.             }
  597.             _loc4_ = sort.findItem(localIndex,param1,Sort.LAST_INDEX_MODE);
  598.             _loc2_ = _loc3_;
  599.             while(_loc2_ <= _loc4_)
  600.             {
  601.                if(localIndex[_loc2_] == param1)
  602.                {
  603.                   return _loc2_;
  604.                }
  605.                _loc2_++;
  606.             }
  607.             return -1;
  608.          }
  609.          if(filterFunction != null)
  610.          {
  611.             _loc5_ = int(localIndex.length);
  612.             _loc2_ = 0;
  613.             while(_loc2_ < _loc5_)
  614.             {
  615.                if(localIndex[_loc2_] == param1)
  616.                {
  617.                   return _loc2_;
  618.                }
  619.                _loc2_++;
  620.             }
  621.             return -1;
  622.          }
  623.          return list.getItemIndex(param1);
  624.       }
  625.       
  626.       public function enableAutoUpdate() : void
  627.       {
  628.          if(autoUpdateCounter > 0)
  629.          {
  630.             --autoUpdateCounter;
  631.             if(autoUpdateCounter == 0)
  632.             {
  633.                handlePendingUpdates();
  634.             }
  635.          }
  636.       }
  637.       
  638.       override flash_proxy function getProperty(param1:*) : *
  639.       {
  640.          var index:int = 0;
  641.          var n:Number = NaN;
  642.          var name:* = param1;
  643.          if(name is QName)
  644.          {
  645.             name = name.localName;
  646.          }
  647.          index = -1;
  648.          try
  649.          {
  650.             n = parseInt(String(name));
  651.             if(!isNaN(n))
  652.             {
  653.                index = int(n);
  654.             }
  655.          }
  656.          catch(e:Error)
  657.          {
  658.          }
  659.          if(index == -1)
  660.          {
  661.             throw new Error(StringUtil.substitute(resourceUnknownProperty,name));
  662.          }
  663.          return getItemAt(index);
  664.       }
  665.       
  666.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  667.       {
  668.          var _loc2_:ListCollectionViewBookmark = null;
  669.          if(!(param1 is ListCollectionViewBookmark) || ListCollectionViewBookmark(param1).mx_internal::view != this)
  670.          {
  671.             throw new CollectionViewError(resourceBookmarkNotFound);
  672.          }
  673.          _loc2_ = ListCollectionViewBookmark(param1);
  674.          if(_loc2_.mx_internal::viewRevision != revision)
  675.          {
  676.             if(_loc2_.mx_internal::index < 0 || _loc2_.mx_internal::index >= length || getItemAt(_loc2_.mx_internal::index) != _loc2_.value)
  677.             {
  678.                _loc2_.mx_internal::index = getItemIndex(_loc2_.value);
  679.             }
  680.             _loc2_.mx_internal::viewRevision = revision;
  681.          }
  682.          return _loc2_.mx_internal::index;
  683.       }
  684.       
  685.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  686.       {
  687.          eventDispatcher.addEventListener(param1,param2,param3,param4,param5);
  688.       }
  689.       
  690.       public function removeItemAt(param1:int) : Object
  691.       {
  692.          var _loc2_:int = 0;
  693.          var _loc3_:Object = null;
  694.          if(param1 < 0 || param1 >= length)
  695.          {
  696.             throw new RangeError(StringUtil.substitute(resourceOutOfBounds,param1));
  697.          }
  698.          _loc2_ = param1;
  699.          if(localIndex)
  700.          {
  701.             _loc3_ = localIndex[param1];
  702.             _loc2_ = list.getItemIndex(_loc3_);
  703.          }
  704.          return list.removeItemAt(_loc2_);
  705.       }
  706.       
  707.       override flash_proxy function callProperty(param1:*, ... rest) : *
  708.       {
  709.          return null;
  710.       }
  711.       
  712.       public function initialized(param1:Object, param2:String) : void
  713.       {
  714.          refresh();
  715.       }
  716.       
  717.       public function setItemAt(param1:Object, param2:int) : Object
  718.       {
  719.          var _loc3_:int = 0;
  720.          var _loc4_:Object = null;
  721.          if(param2 < 0 || !list || param2 >= length)
  722.          {
  723.             throw new RangeError(StringUtil.substitute(resourceOutOfBounds,param2));
  724.          }
  725.          _loc3_ = param2;
  726.          if(localIndex)
  727.          {
  728.             if(param2 > localIndex.length)
  729.             {
  730.                _loc3_ = list.length;
  731.             }
  732.             else
  733.             {
  734.                _loc4_ = localIndex[param2];
  735.                _loc3_ = list.getItemIndex(_loc4_);
  736.             }
  737.          }
  738.          return list.setItemAt(param1,_loc3_);
  739.       }
  740.       
  741.       mx_internal function reset() : void
  742.       {
  743.          var _loc1_:CollectionEvent = null;
  744.          internalRefresh(false);
  745.          _loc1_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  746.          _loc1_.kind = CollectionEventKind.RESET;
  747.          dispatchEvent(_loc1_);
  748.       }
  749.       
  750.       override flash_proxy function setProperty(param1:*, param2:*) : void
  751.       {
  752.          var index:int = 0;
  753.          var n:Number = NaN;
  754.          var name:* = param1;
  755.          var value:* = param2;
  756.          if(name is QName)
  757.          {
  758.             name = name.localName;
  759.          }
  760.          index = -1;
  761.          try
  762.          {
  763.             n = parseInt(String(name));
  764.             if(!isNaN(n))
  765.             {
  766.                index = int(n);
  767.             }
  768.          }
  769.          catch(e:Error)
  770.          {
  771.          }
  772.          if(index == -1)
  773.          {
  774.             throw new Error(StringUtil.substitute(resourceUnknownProperty,name));
  775.          }
  776.          setItemAt(value,index);
  777.       }
  778.       
  779.       override flash_proxy function nextNameIndex(param1:int) : int
  780.       {
  781.          return param1 < length ? param1 + 1 : 0;
  782.       }
  783.       
  784.       public function set list(param1:IList) : void
  785.       {
  786.          var _loc2_:* = false;
  787.          var _loc3_:* = false;
  788.          if(_list != param1)
  789.          {
  790.             if(_list)
  791.             {
  792.                _list.removeEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler);
  793.                _loc2_ = _list.length > 0;
  794.             }
  795.             _list = param1;
  796.             if(_list)
  797.             {
  798.                _list.addEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler,false,0,true);
  799.                _loc3_ = _list.length > 0;
  800.             }
  801.             if(_loc2_ || _loc3_)
  802.             {
  803.                mx_internal::reset();
  804.             }
  805.             dispatchEvent(new Event("listChanged"));
  806.          }
  807.       }
  808.       
  809.       public function toArray() : Array
  810.       {
  811.          var _loc1_:Array = null;
  812.          if(localIndex)
  813.          {
  814.             _loc1_ = localIndex.concat();
  815.          }
  816.          else
  817.          {
  818.             _loc1_ = list.toArray();
  819.          }
  820.          return _loc1_;
  821.       }
  822.       
  823.       private function internalRefresh(param1:Boolean) : Boolean
  824.       {
  825.          var tmp:Array = null;
  826.          var len:int = 0;
  827.          var i:int = 0;
  828.          var item:Object = null;
  829.          var refreshEvent:CollectionEvent = null;
  830.          var dispatch:Boolean = param1;
  831.          if(Boolean(sort) || filterFunction != null)
  832.          {
  833.             try
  834.             {
  835.                populateLocalIndex();
  836.             }
  837.             catch(pending:ItemPendingError)
  838.             {
  839.                pending.addResponder(new ItemResponder(function(param1:Object, param2:Object = null):void
  840.                {
  841.                   internalRefresh(dispatch);
  842.                },function(param1:Object, param2:Object = null):void
  843.                {
  844.                }));
  845.                return false;
  846.             }
  847.             if(filterFunction != null)
  848.             {
  849.                tmp = [];
  850.                len = int(localIndex.length);
  851.                i = 0;
  852.                while(i < len)
  853.                {
  854.                   item = localIndex[i];
  855.                   if(filterFunction(item))
  856.                   {
  857.                      tmp.push(item);
  858.                   }
  859.                   i++;
  860.                }
  861.                localIndex = tmp;
  862.             }
  863.             if(sort)
  864.             {
  865.                sort.sort(localIndex);
  866.                dispatch = true;
  867.             }
  868.          }
  869.          else if(localIndex)
  870.          {
  871.             localIndex = null;
  872.          }
  873.          ++revision;
  874.          pendingUpdates = null;
  875.          if(dispatch)
  876.          {
  877.             refreshEvent = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  878.             refreshEvent.kind = CollectionEventKind.REFRESH;
  879.             dispatchEvent(refreshEvent);
  880.          }
  881.          return true;
  882.       }
  883.       
  884.       public function disableAutoUpdate() : void
  885.       {
  886.          ++autoUpdateCounter;
  887.       }
  888.       
  889.       public function refresh() : Boolean
  890.       {
  891.          return internalRefresh(true);
  892.       }
  893.       
  894.       public function addItem(param1:Object) : void
  895.       {
  896.          addItemAt(param1,length);
  897.       }
  898.       
  899.       [Bindable("filterFunctionChanged")]
  900.       public function get filterFunction() : Function
  901.       {
  902.          return _filterFunction;
  903.       }
  904.       
  905.       public function createCursor() : IViewCursor
  906.       {
  907.          return new ListCollectionViewCursor(this);
  908.       }
  909.       
  910.       public function hasEventListener(param1:String) : Boolean
  911.       {
  912.          return eventDispatcher.hasEventListener(param1);
  913.       }
  914.       
  915.       [Bindable("collectionChange")]
  916.       public function get length() : int
  917.       {
  918.          if(localIndex)
  919.          {
  920.             return localIndex.length;
  921.          }
  922.          if(list)
  923.          {
  924.             return list.length;
  925.          }
  926.          return 0;
  927.       }
  928.       
  929.       public function toString() : String
  930.       {
  931.          if(localIndex)
  932.          {
  933.             return ObjectUtil.toString(localIndex);
  934.          }
  935.          if(Boolean(list) && Boolean(Object(list).toString))
  936.          {
  937.             return Object(list).toString();
  938.          }
  939.          return getQualifiedClassName(this);
  940.       }
  941.       
  942.       private function listChangeHandler(param1:CollectionEvent) : void
  943.       {
  944.          if(autoUpdateCounter > 0)
  945.          {
  946.             if(!pendingUpdates)
  947.             {
  948.                pendingUpdates = [];
  949.             }
  950.             pendingUpdates.push(param1);
  951.          }
  952.          else
  953.          {
  954.             switch(param1.kind)
  955.             {
  956.                case CollectionEventKind.ADD:
  957.                   addItemsToView(param1.items,param1.location);
  958.                   break;
  959.                case CollectionEventKind.RESET:
  960.                   mx_internal::reset();
  961.                   break;
  962.                case CollectionEventKind.REMOVE:
  963.                   removeItemsFromView(param1.items,param1.location);
  964.                   break;
  965.                case CollectionEventKind.REPLACE:
  966.                   replaceItemsInView(param1.items,param1.location);
  967.                   break;
  968.                case CollectionEventKind.UPDATE:
  969.                   handlePropertyChangeEvents(param1.items);
  970.                   break;
  971.                default:
  972.                   dispatchEvent(param1);
  973.             }
  974.          }
  975.       }
  976.    }
  977. }
  978.  
  979. import flash.events.EventDispatcher;
  980. import flash.system.ApplicationDomain;
  981. import mx.collections.errors.CollectionViewError;
  982. import mx.collections.errors.CursorError;
  983. import mx.collections.errors.ItemPendingError;
  984. import mx.collections.errors.SortError;
  985. import mx.core.mx_internal;
  986. import mx.events.CollectionEvent;
  987. import mx.events.CollectionEventKind;
  988. import mx.events.FlexEvent;
  989. import mx.resources.ResourceBundle;
  990.  
  991. use namespace mx_internal;
  992.  
  993. class ListCollectionViewBookmark extends CursorBookmark
  994. {
  995.    mx_internal var viewRevision:int;
  996.    
  997.    mx_internal var view:ListCollectionView;
  998.    
  999.    mx_internal var index:int;
  1000.    
  1001.    public function ListCollectionViewBookmark(param1:Object, param2:ListCollectionView, param3:int, param4:int)
  1002.    {
  1003.       super(param1);
  1004.       this.mx_internal::view = param2;
  1005.       this.mx_internal::viewRevision = param3;
  1006.       this.mx_internal::index = param4;
  1007.    }
  1008.    
  1009.    override public function getViewIndex() : int
  1010.    {
  1011.       return mx_internal::view.mx_internal::getBookmarkIndex(this);
  1012.    }
  1013. }
  1014.  
  1015. class ListCollectionViewCursor extends EventDispatcher implements IViewCursor
  1016. {
  1017.    private static var resourceInvalidInsert:String;
  1018.    
  1019.    private static var resourceInvalidRemove:String;
  1020.    
  1021.    private static var resourceInvalidBookmark:String;
  1022.    
  1023.    private static var resourceBookmarkInvalid:String;
  1024.    
  1025.    private static var resourceInvalidCursor:String;
  1026.    
  1027.    private static const BEFORE_FIRST_INDEX:int = -1;
  1028.    
  1029.    private static const AFTER_LAST_INDEX:int = -2;
  1030.    
  1031.    private static var packageResources:ResourceBundle = ResourceBundle.getResourceBundle("collections",ApplicationDomain.currentDomain);
  1032.    
  1033.    loadResources();
  1034.    
  1035.    private var _view:ListCollectionView;
  1036.    
  1037.    private var currentValue:Object;
  1038.    
  1039.    private var currentIndex:int;
  1040.    
  1041.    private var invalid:Boolean;
  1042.    
  1043.    public function ListCollectionViewCursor(param1:ListCollectionView)
  1044.    {
  1045.       var view:ListCollectionView = param1;
  1046.       super();
  1047.       _view = view;
  1048.       _view.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionEventHandler,false,0,true);
  1049.       currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  1050.       if(currentIndex == 0)
  1051.       {
  1052.          try
  1053.          {
  1054.             setCurrent(view.getItemAt(0),false);
  1055.          }
  1056.          catch(e:ItemPendingError)
  1057.          {
  1058.             currentIndex = BEFORE_FIRST_INDEX;
  1059.             setCurrent(null,false);
  1060.          }
  1061.       }
  1062.    }
  1063.    
  1064.    private static function loadResources() : void
  1065.    {
  1066.       resourceInvalidInsert = packageResources.getString("invalidInsert");
  1067.       resourceInvalidRemove = packageResources.getString("invalidRemove");
  1068.       resourceBookmarkInvalid = packageResources.getString("bookmarkInvalid");
  1069.       resourceInvalidBookmark = packageResources.getString("invalidBookmark");
  1070.       resourceInvalidCursor = packageResources.getString("invalidCursor");
  1071.    }
  1072.    
  1073.    public function movePrevious() : Boolean
  1074.    {
  1075.       var _loc1_:int = 0;
  1076.       if(beforeFirst)
  1077.       {
  1078.          return false;
  1079.       }
  1080.       _loc1_ = !!afterLast ? int(view.length - 1) : int(currentIndex - 1);
  1081.       if(_loc1_ == -1)
  1082.       {
  1083.          _loc1_ = int(BEFORE_FIRST_INDEX);
  1084.          setCurrent(null);
  1085.       }
  1086.       else
  1087.       {
  1088.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1089.       }
  1090.       currentIndex = _loc1_;
  1091.       return !beforeFirst;
  1092.    }
  1093.    
  1094.    [Bindable("cursorUpdate")]
  1095.    public function get beforeFirst() : Boolean
  1096.    {
  1097.       checkValid();
  1098.       return currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  1099.    }
  1100.    
  1101.    public function remove() : Object
  1102.    {
  1103.       var oldIndex:int = 0;
  1104.       var removed:Object = null;
  1105.       if(Boolean(beforeFirst) || Boolean(afterLast))
  1106.       {
  1107.          throw new CursorError(resourceInvalidRemove);
  1108.       }
  1109.       oldIndex = int(currentIndex);
  1110.       ++currentIndex;
  1111.       if(currentIndex >= view.length)
  1112.       {
  1113.          currentIndex = AFTER_LAST_INDEX;
  1114.          setCurrent(null);
  1115.       }
  1116.       else
  1117.       {
  1118.          try
  1119.          {
  1120.             setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1121.          }
  1122.          catch(e:ItemPendingError)
  1123.          {
  1124.             setCurrent(null,false);
  1125.             ListCollectionView(view).removeItemAt(oldIndex);
  1126.             throw e;
  1127.          }
  1128.       }
  1129.       removed = ListCollectionView(view).removeItemAt(oldIndex);
  1130.       return removed;
  1131.    }
  1132.    
  1133.    private function collectionEventHandler(param1:CollectionEvent) : void
  1134.    {
  1135.       var event:CollectionEvent = param1;
  1136.       switch(event.kind)
  1137.       {
  1138.          case CollectionEventKind.ADD:
  1139.             if(event.location <= currentIndex)
  1140.             {
  1141.                currentIndex += event.items.length;
  1142.             }
  1143.             break;
  1144.          case CollectionEventKind.REMOVE:
  1145.             if(event.location < currentIndex)
  1146.             {
  1147.                currentIndex -= event.items.length;
  1148.             }
  1149.             else if(event.location == currentIndex)
  1150.             {
  1151.                if(currentIndex < view.length)
  1152.                {
  1153.                   try
  1154.                   {
  1155.                      setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1156.                   }
  1157.                   catch(error:ItemPendingError)
  1158.                   {
  1159.                      setCurrent(null,false);
  1160.                   }
  1161.                }
  1162.                else
  1163.                {
  1164.                   currentIndex = AFTER_LAST_INDEX;
  1165.                   setCurrent(null);
  1166.                }
  1167.             }
  1168.             break;
  1169.          case CollectionEventKind.MOVE:
  1170.             if(event.oldLocation == currentIndex)
  1171.             {
  1172.                currentIndex = event.location;
  1173.             }
  1174.             else
  1175.             {
  1176.                if(event.oldLocation < currentIndex)
  1177.                {
  1178.                   currentIndex -= event.items.length;
  1179.                }
  1180.                if(event.location <= currentIndex)
  1181.                {
  1182.                   currentIndex += event.items.length;
  1183.                }
  1184.             }
  1185.             break;
  1186.          case CollectionEventKind.REFRESH:
  1187.             if(!(Boolean(beforeFirst) || Boolean(afterLast)))
  1188.             {
  1189.                currentIndex = ListCollectionView(view).getItemIndex(currentValue);
  1190.                if(currentIndex == -1)
  1191.                {
  1192.                   setCurrent(null);
  1193.                }
  1194.             }
  1195.             break;
  1196.          case CollectionEventKind.REPLACE:
  1197.             if(event.location == currentIndex)
  1198.             {
  1199.                try
  1200.                {
  1201.                   setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1202.                }
  1203.                catch(error:ItemPendingError)
  1204.                {
  1205.                   setCurrent(null,false);
  1206.                }
  1207.             }
  1208.             break;
  1209.          case CollectionEventKind.RESET:
  1210.             currentIndex = BEFORE_FIRST_INDEX;
  1211.             setCurrent(null);
  1212.       }
  1213.    }
  1214.    
  1215.    [Bindable("cursorUpdate")]
  1216.    public function get current() : Object
  1217.    {
  1218.       checkValid();
  1219.       return currentValue;
  1220.    }
  1221.    
  1222.    [Bindable("cursorUpdate")]
  1223.    public function get afterLast() : Boolean
  1224.    {
  1225.       checkValid();
  1226.       return currentIndex == AFTER_LAST_INDEX || view.length == 0;
  1227.    }
  1228.    
  1229.    public function findFirst(param1:Object) : Boolean
  1230.    {
  1231.       var lcView:ListCollectionView = null;
  1232.       var index:int = 0;
  1233.       var values:Object = param1;
  1234.       checkValid();
  1235.       lcView = ListCollectionView(view);
  1236.       try
  1237.       {
  1238.          index = lcView.mx_internal::findItem(values,Sort.FIRST_INDEX_MODE);
  1239.       }
  1240.       catch(sortError:SortError)
  1241.       {
  1242.          throw new CursorError(sortError.message);
  1243.       }
  1244.       if(index > -1)
  1245.       {
  1246.          currentIndex = index;
  1247.          setCurrent(lcView.getItemAt(currentIndex));
  1248.       }
  1249.       return index > -1;
  1250.    }
  1251.    
  1252.    public function get view() : ICollectionView
  1253.    {
  1254.       checkValid();
  1255.       return _view;
  1256.    }
  1257.    
  1258.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  1259.    {
  1260.       currentValue = param1;
  1261.       if(param2)
  1262.       {
  1263.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  1264.       }
  1265.    }
  1266.    
  1267.    public function insert(param1:Object) : void
  1268.    {
  1269.       var _loc2_:int = 0;
  1270.       if(afterLast)
  1271.       {
  1272.          _loc2_ = int(view.length);
  1273.       }
  1274.       else if(beforeFirst)
  1275.       {
  1276.          if(view.length > 0)
  1277.          {
  1278.             throw new CursorError(resourceInvalidInsert);
  1279.          }
  1280.          _loc2_ = 0;
  1281.       }
  1282.       else
  1283.       {
  1284.          _loc2_ = int(currentIndex);
  1285.       }
  1286.       ListCollectionView(view).addItemAt(param1,_loc2_);
  1287.    }
  1288.    
  1289.    [Bindable("cursorUpdate")]
  1290.    public function get bookmark() : CursorBookmark
  1291.    {
  1292.       checkValid();
  1293.       if(view.length == 0 || Boolean(beforeFirst))
  1294.       {
  1295.          return CursorBookmark.FIRST;
  1296.       }
  1297.       if(afterLast)
  1298.       {
  1299.          return CursorBookmark.LAST;
  1300.       }
  1301.       return ListCollectionView(view).mx_internal::getBookmark(currentIndex);
  1302.    }
  1303.    
  1304.    private function checkValid() : void
  1305.    {
  1306.       if(invalid)
  1307.       {
  1308.          throw new CursorError(resourceInvalidCursor);
  1309.       }
  1310.    }
  1311.    
  1312.    public function moveNext() : Boolean
  1313.    {
  1314.       var _loc1_:int = 0;
  1315.       if(afterLast)
  1316.       {
  1317.          return false;
  1318.       }
  1319.       _loc1_ = !!beforeFirst ? 0 : int(currentIndex + 1);
  1320.       if(_loc1_ >= view.length)
  1321.       {
  1322.          _loc1_ = int(AFTER_LAST_INDEX);
  1323.          setCurrent(null);
  1324.       }
  1325.       else
  1326.       {
  1327.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1328.       }
  1329.       currentIndex = _loc1_;
  1330.       return !afterLast;
  1331.    }
  1332.    
  1333.    public function findLast(param1:Object) : Boolean
  1334.    {
  1335.       var lcView:ListCollectionView = null;
  1336.       var index:int = 0;
  1337.       var values:Object = param1;
  1338.       checkValid();
  1339.       lcView = ListCollectionView(view);
  1340.       try
  1341.       {
  1342.          index = lcView.mx_internal::findItem(values,Sort.LAST_INDEX_MODE);
  1343.       }
  1344.       catch(sortError:SortError)
  1345.       {
  1346.          throw new CursorError(sortError.message);
  1347.       }
  1348.       if(index > -1)
  1349.       {
  1350.          currentIndex = index;
  1351.          setCurrent(lcView.getItemAt(currentIndex));
  1352.       }
  1353.       return index > -1;
  1354.    }
  1355.    
  1356.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  1357.    {
  1358.       var newIndex:int = 0;
  1359.       var newCurrent:Object = null;
  1360.       var bookmark:CursorBookmark = param1;
  1361.       var offset:int = param2;
  1362.       var prefetch:int = param3;
  1363.       checkValid();
  1364.       if(view.length == 0)
  1365.       {
  1366.          currentIndex = AFTER_LAST_INDEX;
  1367.          setCurrent(null,false);
  1368.          return;
  1369.       }
  1370.       newIndex = int(currentIndex);
  1371.       if(bookmark == CursorBookmark.FIRST)
  1372.       {
  1373.          newIndex = 0;
  1374.       }
  1375.       else if(bookmark == CursorBookmark.LAST)
  1376.       {
  1377.          newIndex = view.length - 1;
  1378.       }
  1379.       else if(bookmark != CursorBookmark.CURRENT)
  1380.       {
  1381.          try
  1382.          {
  1383.             newIndex = ListCollectionView(view).mx_internal::getBookmarkIndex(bookmark);
  1384.             if(newIndex < 0)
  1385.             {
  1386.                setCurrent(null);
  1387.                throw new CursorError(resourceBookmarkInvalid);
  1388.             }
  1389.          }
  1390.          catch(bmError:CollectionViewError)
  1391.          {
  1392.             throw new CursorError(resourceInvalidBookmark);
  1393.          }
  1394.       }
  1395.       newIndex += offset;
  1396.       newCurrent = null;
  1397.       if(newIndex >= view.length)
  1398.       {
  1399.          currentIndex = AFTER_LAST_INDEX;
  1400.       }
  1401.       else if(newIndex < 0)
  1402.       {
  1403.          currentIndex = BEFORE_FIRST_INDEX;
  1404.       }
  1405.       else
  1406.       {
  1407.          newCurrent = ListCollectionView(view).getItemAt(newIndex,prefetch);
  1408.          currentIndex = newIndex;
  1409.       }
  1410.       setCurrent(newCurrent);
  1411.    }
  1412.    
  1413.    public function findAny(param1:Object) : Boolean
  1414.    {
  1415.       var lcView:ListCollectionView = null;
  1416.       var index:int = 0;
  1417.       var values:Object = param1;
  1418.       checkValid();
  1419.       lcView = ListCollectionView(view);
  1420.       try
  1421.       {
  1422.          index = lcView.mx_internal::findItem(values,Sort.ANY_INDEX_MODE);
  1423.       }
  1424.       catch(e:SortError)
  1425.       {
  1426.          throw new CursorError(e.message);
  1427.       }
  1428.       if(index > -1)
  1429.       {
  1430.          currentIndex = index;
  1431.          setCurrent(lcView.getItemAt(currentIndex));
  1432.       }
  1433.       return index > -1;
  1434.    }
  1435. }
  1436.